home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Interfaces & Libraries / Interfaces / PInterfaces / Lists.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  9.3 KB  |  336 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Lists.p
  3.  
  4.      Contains:    List Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Lists;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __LISTS__}
  30. {$SETC __LISTS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC ListsIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __CONTROLS__}
  43. {$I Controls.p}
  44. {$ENDC}
  45. {    Quickdraw.p                                                    }
  46. {        MixedMode.p                                                }
  47. {        QuickdrawText.p                                            }
  48. {    Menus.p                                                        }
  49. {        Memory.p                                                }
  50.  
  51. {$IFC UNDEFINED __MEMORY__}
  52. {$I Memory.p}
  53. {$ENDC}
  54.  
  55. {$PUSH}
  56. {$ALIGN MAC68K}
  57. {$LibExport+}
  58. {$IFC UNDEFINED STRICT_LISTS }
  59. {$SETC STRICT_LISTS := 0}
  60. {$ENDC}
  61. {$IFC NOT STRICT_LISTS }
  62.  
  63. CONST
  64.     lDoVAutoscroll                = 2;
  65.     lDoHAutoscroll                = 1;
  66.     lOnlyOne                    = -128;
  67.     lExtendDrag                    = 64;
  68.     lNoDisjoint                    = 32;
  69.     lNoExtend                    = 16;
  70.     lNoRect                        = 8;
  71.     lUseSense                    = 4;
  72.     lNoNilHilite                = 2;
  73.  
  74.     lDoVAutoscrollBit            = 1;
  75.     lDoHAutoscrollBit            = 0;
  76.     lOnlyOneBit                    = 7;
  77.     lExtendDragBit                = 6;
  78.     lNoDisjointBit                = 5;
  79.     lNoExtendBit                = 4;
  80.     lNoRectBit                    = 3;
  81.     lUseSenseBit                = 2;
  82.     lNoNilHiliteBit                = 1;
  83.  
  84. {$ENDC}
  85.  
  86. CONST
  87.     lInitMsg                    = 0;
  88.     lDrawMsg                    = 1;
  89.     lHiliteMsg                    = 2;
  90.     lCloseMsg                    = 3;
  91.  
  92. {$IFC STRICT_LISTS }
  93.     
  94. TYPE
  95.     ListRef = Ptr;
  96.  
  97.     ListHandle = ListRef;
  98.  
  99. {$ELSEC}
  100.     
  101. TYPE
  102.     ListPtr = ^ListRec;
  103.     ListHandle = ^ListPtr;
  104.  
  105.     ListRef = ListHandle;
  106.  
  107. {$ENDC}
  108.     Cell = Point;
  109.  
  110.     ListBounds = Rect;
  111.  
  112.     DataArray = PACKED ARRAY [0..32000] OF CHAR;
  113.  
  114.     DataPtr = ^DataArray;
  115.     DataHandle = ^DataPtr;
  116.  
  117.     ListSearchProcPtr = ProcPtr;  { FUNCTION ListSearch(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER): INTEGER; }
  118.     {
  119.         ListClickLoopProcPtr uses register based parameters on the 68k and cannot
  120.         be written in or called from a high-level language without the help of
  121.         mixed mode or assembly glue.
  122.  
  123.         In:
  124.          =>                 .?
  125.         Out:
  126.          <= return value    D0.B
  127.     }
  128.     ListClickLoopProcPtr = Register68kProcPtr;  { register FUNCTION ListClickLoop: BOOLEAN; }
  129.     ListSearchUPP = UniversalProcPtr;
  130.     ListClickLoopUPP = UniversalProcPtr;
  131.  
  132. {$IFC NOT STRICT_LISTS }
  133.     ListRec = RECORD
  134.         rView:                    Rect;
  135.         port:                    GrafPtr;
  136.         indent:                    Point;
  137.         cellSize:                Point;
  138.         visible:                ListBounds;
  139.         vScroll:                ControlRef;
  140.         hScroll:                ControlRef;
  141.         selFlags:                SInt8;
  142.         lActive:                BOOLEAN;
  143.         lReserved:                SInt8;
  144.         listFlags:                SInt8;
  145.         clikTime:                LONGINT;
  146.         clikLoc:                Point;
  147.         mouseLoc:                Point;
  148.         lClickLoop:                ListClickLoopUPP;
  149.         lastClick:                Cell;
  150.         refCon:                    LONGINT;
  151.         listDefProc:            Handle;
  152.         userHandle:                Handle;
  153.         dataBounds:                ListBounds;
  154.         cells:                    DataHandle;
  155.         maxIndex:                INTEGER;
  156.         cellArray:                ARRAY [0..0] OF INTEGER;
  157.     END;
  158.  
  159. {$ENDC}
  160.     ListDefProcPtr = ProcPtr;  { PROCEDURE ListDef(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef); }
  161.     ListCellDrawProcPtr = ProcPtr;  { PROCEDURE ListCellDraw(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef); }
  162.     ListDefUPP = UniversalProcPtr;
  163.     ListCellDrawUPP = UniversalProcPtr;
  164.  
  165. CONST
  166.     uppListSearchProcInfo = $00002BE0; { FUNCTION (4 byte param, 4 byte param, 2 byte param, 2 byte param): 2 byte result; }
  167.     uppListClickLoopProcInfo = $00000012; { Register FUNCTION : 1 byte in D0; }
  168.     uppListDefProcInfo = $000EBD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 2 byte param, 2 byte param, 4 byte param); }
  169.     uppListCellDrawProcInfo = $000EFD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  170.  
  171. FUNCTION NewListSearchProc(userRoutine: ListSearchProcPtr): ListSearchUPP;
  172.     {$IFC NOT GENERATINGCFM }
  173.     INLINE $2E9F;
  174.     {$ENDC}
  175.  
  176. FUNCTION NewListClickLoopProc(userRoutine: ListClickLoopProcPtr): ListClickLoopUPP;
  177.     {$IFC NOT GENERATINGCFM }
  178.     INLINE $2E9F;
  179.     {$ENDC}
  180.  
  181. FUNCTION NewListDefProc(userRoutine: ListDefProcPtr): ListDefUPP;
  182.     {$IFC NOT GENERATINGCFM }
  183.     INLINE $2E9F;
  184.     {$ENDC}
  185.  
  186. FUNCTION NewListCellDrawProc(userRoutine: ListCellDrawProcPtr): ListCellDrawUPP;
  187.     {$IFC NOT GENERATINGCFM }
  188.     INLINE $2E9F;
  189.     {$ENDC}
  190.  
  191. FUNCTION CallListSearchProc(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER; userRoutine: ListSearchUPP): INTEGER;
  192.     {$IFC NOT GENERATINGCFM}
  193.     INLINE $205F, $4E90;
  194.     {$ENDC}
  195.  
  196. FUNCTION CallListClickLoopProc(userRoutine: ListClickLoopUPP): BOOLEAN;
  197.     {$IFC NOT GENERATINGCFM}
  198.     {To be implemented:  Glue to move parameters into registers.}
  199.     {$ENDC}
  200.  
  201. PROCEDURE CallListDefProc(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListDefUPP);
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $205F, $4E90;
  204.     {$ENDC}
  205.  
  206. PROCEDURE CallListCellDrawProc(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListCellDrawUPP);
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $205F, $4E90;
  209.     {$ENDC}
  210.  
  211. FUNCTION LNew({CONST}VAR rView: Rect; {CONST}VAR dataBounds: ListBounds; cSize: Point; theProc: INTEGER; theWindow: WindowRef; drawIt: BOOLEAN; hasGrow: BOOLEAN; scrollHoriz: BOOLEAN; scrollVert: BOOLEAN): ListRef;
  212.     {$IFC NOT GENERATINGCFM}
  213.     INLINE $3F3C, $0044, $A9E7;
  214.     {$ENDC}
  215. PROCEDURE LDispose(lHandle: ListRef);
  216.     {$IFC NOT GENERATINGCFM}
  217.     INLINE $3F3C, $0028, $A9E7;
  218.     {$ENDC}
  219. FUNCTION LAddColumn(count: INTEGER; colNum: INTEGER; lHandle: ListRef): INTEGER;
  220.     {$IFC NOT GENERATINGCFM}
  221.     INLINE $3F3C, $0004, $A9E7;
  222.     {$ENDC}
  223. FUNCTION LAddRow(count: INTEGER; rowNum: INTEGER; lHandle: ListRef): INTEGER;
  224.     {$IFC NOT GENERATINGCFM}
  225.     INLINE $3F3C, $0008, $A9E7;
  226.     {$ENDC}
  227. PROCEDURE LDelColumn(count: INTEGER; colNum: INTEGER; lHandle: ListRef);
  228.     {$IFC NOT GENERATINGCFM}
  229.     INLINE $3F3C, $0020, $A9E7;
  230.     {$ENDC}
  231. PROCEDURE LDelRow(count: INTEGER; rowNum: INTEGER; lHandle: ListRef);
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $3F3C, $0024, $A9E7;
  234.     {$ENDC}
  235. FUNCTION LGetSelect(next: BOOLEAN; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $3F3C, $003C, $A9E7;
  238.     {$ENDC}
  239. FUNCTION LLastClick(lHandle: ListRef): Cell;
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $3F3C, $0040, $A9E7;
  242.     {$ENDC}
  243. FUNCTION LNextCell(hNext: BOOLEAN; vNext: BOOLEAN; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  244.     {$IFC NOT GENERATINGCFM}
  245.     INLINE $3F3C, $0048, $A9E7;
  246.     {$ENDC}
  247. FUNCTION LSearch(dataPtr: UNIV Ptr; dataLen: INTEGER; searchProc: ListSearchUPP; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  248.     {$IFC NOT GENERATINGCFM}
  249.     INLINE $3F3C, $0054, $A9E7;
  250.     {$ENDC}
  251. PROCEDURE LSize(listWidth: INTEGER; listHeight: INTEGER; lHandle: ListRef);
  252.     {$IFC NOT GENERATINGCFM}
  253.     INLINE $3F3C, $0060, $A9E7;
  254.     {$ENDC}
  255. PROCEDURE LSetDrawingMode(drawIt: BOOLEAN; lHandle: ListRef);
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $3F3C, $002C, $A9E7;
  258.     {$ENDC}
  259. PROCEDURE LScroll(dCols: INTEGER; dRows: INTEGER; lHandle: ListRef);
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $3F3C, $0050, $A9E7;
  262.     {$ENDC}
  263. PROCEDURE LAutoScroll(lHandle: ListRef);
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $3F3C, $0010, $A9E7;
  266.     {$ENDC}
  267. PROCEDURE LUpdate(theRgn: RgnHandle; lHandle: ListRef);
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $3F3C, $0064, $A9E7;
  270.     {$ENDC}
  271. PROCEDURE LActivate(act: BOOLEAN; lHandle: ListRef);
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $4267, $A9E7;
  274.     {$ENDC}
  275. PROCEDURE LCellSize(cSize: Point; lHandle: ListRef);
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $3F3C, $0014, $A9E7;
  278.     {$ENDC}
  279. FUNCTION LClick(pt: Point; modifiers: INTEGER; lHandle: ListRef): BOOLEAN;
  280.     {$IFC NOT GENERATINGCFM}
  281.     INLINE $3F3C, $0018, $A9E7;
  282.     {$ENDC}
  283. PROCEDURE LAddToCell(dataPtr: UNIV Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $3F3C, $000C, $A9E7;
  286.     {$ENDC}
  287. PROCEDURE LClrCell(theCell: Cell; lHandle: ListRef);
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $3F3C, $001C, $A9E7;
  290.     {$ENDC}
  291. PROCEDURE LGetCell(dataPtr: UNIV Ptr; VAR dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $3F3C, $0038, $A9E7;
  294.     {$ENDC}
  295. PROCEDURE LRect(VAR cellRect: Rect; theCell: Cell; lHandle: ListRef);
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $3F3C, $004C, $A9E7;
  298.     {$ENDC}
  299. PROCEDURE LSetCell(dataPtr: UNIV Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $3F3C, $0058, $A9E7;
  302.     {$ENDC}
  303. PROCEDURE LSetSelect(setIt: BOOLEAN; theCell: Cell; lHandle: ListRef);
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $3F3C, $005C, $A9E7;
  306.     {$ENDC}
  307. PROCEDURE LDraw(theCell: Cell; lHandle: ListRef);
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $3F3C, $0030, $A9E7;
  310.     {$ENDC}
  311. PROCEDURE LGetCellDataLocation(VAR offset: INTEGER; VAR len: INTEGER; theCell: Cell; lHandle: ListRef);
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $3F3C, $0034, $A9E7;
  314.     {$ENDC}
  315. {$IFC OLDROUTINENAMES }
  316. PROCEDURE LDoDraw(drawIt: BOOLEAN; lHandle: ListRef);
  317.     {$IFC NOT GENERATINGCFM}
  318.     INLINE $3F3C, $002C, $A9E7;
  319.     {$ENDC}
  320. PROCEDURE LFind(VAR offset: INTEGER; VAR len: INTEGER; theCell: Cell; lHandle: ListRef);
  321.     {$IFC NOT GENERATINGCFM}
  322.     INLINE $3F3C, $0034, $A9E7;
  323.     {$ENDC}
  324. {$ENDC}
  325.  
  326. {$ALIGN RESET}
  327. {$POP}
  328.  
  329. {$SETC UsingIncludes := ListsIncludes}
  330.  
  331. {$ENDC} {__LISTS__}
  332.  
  333. {$IFC NOT UsingIncludes}
  334.  END.
  335. {$ENDC}
  336.